rochars / alawmulaw

 * alawmulaw: A-Law and mu-Law codecs in JavaScript.

 * https://github.com/rochars/alawmulaw

 *

 * Copyright (c) 2018 Rafael da Silva Rocha.

 *

 * Permission is hereby granted, free of charge, to any person obtaining

 * a copy of this software and associated documentation files (the

 * "Software"), to deal in the Software without restriction, including

 * without limitation the rights to use, copy, modify, merge, publish,

 * distribute, sublicense, and/or sell copies of the Software, and to

 * permit persons to whom the Software is furnished to do so, subject to

 * the following conditions:

 *

 * The above copyright notice and this permission notice shall be

 * included in all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE

 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION

 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

 *

 */

/**

 * @fileoverview mu-Law codec.

 */

/** @module alawmulaw/mulaw */

/**

 * @type {number}

 * @private

 */

const BIAS = 0x84;

/**

 * Encode a 16-bit linear PCM sample as 8-bit mu-Law.

 * @param {number} sample A 16-bit PCM sample

 * @return {number}

 */

export function encodeSample(sample) {

  /** @type {number} */

  let mask = 0xFF;

  if (sample < 0) {

    sample = BIAS - sample;

    mask = 0x7F;

  } else {

    sample += BIAS;

  }

  if (sample > 0x7FFF) {

    sample = 0x7FFF;

  }

  /** @type {number} */

  let seg = segmentValue_(sample);

  /** @type {number} */

  let uval = (seg << 4) | ((sample >> (seg + 3)) & 0xF);

  return uval ^ mask;

}

/**

 * Decode a 8-bit mu-Law sample as 16-bit PCM.

 * @param {number} muLawSample The 8-bit mu-Law sample

 * @return {number}

 */

  /** @type {number} */

  let t = ((muLawSample & 0xf) << 3) + BIAS;

  t <<= (muLawSample & 0x70) >> 4;

}

/**

 * Encode 16-bit linear PCM samples into 8-bit mu-Law samples.

 * @param {!Int16Array} samples A array of 16-bit PCM samples.

 * @return {!Uint8Array}

 */

export function encode(samples) {

  /** @type {!Uint8Array} */

  let muLawSamples = new Uint8Array(samples.length);

  for (let i=0; i<samples.length; i++) {

    muLawSamples[i] = encodeSample(samples[i]);

  }

  return muLawSamples;

}

/**

 * Decode 8-bit mu-Law samples into 16-bit PCM samples.

 * @param {!Uint8Array} samples A array of 8-bit mu-Law samples.

 * @return {!Int16Array}

 */

export function decode(samples) {

  /** @type {!Int16Array} */

  let pcmSamples = new Int16Array(samples.length);

  for (let i=0; i<samples.length; i++) {

    pcmSamples[i] = decodeSample(samples[i]);

  }

  return pcmSamples;

}

/**

 * Return the segment value of a PCM sample.

 * @param {number} sample

 * @return {number}

 * @private

 */

function segmentValue_(sample) {

  /** @type {number} */

  let segment = 0;

  sample >>= 7;

    sample >>= 4;

    segment += 4;

  }

    sample >>= 2;

    segment += 2;

  }

    segment += 1;

  }

  return segment;

}